<?xml version="1.0"?>
<doc>
    <assembly>
        <name>ESRI.ArcGIS.Client.Toolkit.DataSources</name>
    </assembly>
    <members>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition">
            <summary>
            Converts a KML document into a FeatureDefinition.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.Convert(System.Xml.Linq.XDocument,System.Net.ICredentials)">
            <summary>
            Takes features in the KML document and converts them into equivalent features
            and adds them to the FeatureDefinition.
            </summary>
            <param name="xDoc">LINQ XDocument containing the KML definition to be converted.</param>
            <param name="credentials">The credentials.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.DownloadStyle(System.String,System.Xml.Linq.XElement,System.Net.ICredentials)">
            <summary>
            Downloads KML file containing style, extracts style and creates feature definitions.
            </summary>
            <param name="styleUrl">Style id to locate in file.</param>
            <param name="placemark">Placemark XElement containing feature information.</param>
            <param name="credentials">The credentials.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.StyleDownloaded(System.Object,System.Net.OpenReadCompletedEventArgs)">
            <summary>
            Event handler invoked when an external KML file containing a style definition has been downloaded.
            </summary>
            <param name="sender">Sending object.</param>
            <param name="e">Event arguments including error information and the input stream.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.GetFeatureType(System.Xml.Linq.XElement)">
            <summary>
            Extracts the feature element from the Placemark.
            </summary>
            <param name="element">Placemark node that may contain a supported feature type node.</param>
            <returns>XElement node containing a supported feature type definition.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ExtractPolygon(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle,System.Xml.Linq.XElement)">
            <summary>
            Extracts a polygon from the input element and applies style information to the feature descriptor.
            </summary>
            <param name="kmlStyle">KML Style information.</param>
            <param name="geomElement">Polygon geometry information.</param>
            <returns>A FeatureDescriptor object representing the feature.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ExtractLinearRing(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle,System.Xml.Linq.XElement)">
            <summary>
            Extracts a linear ring from the input element and applies style information to the feature descriptor.
            </summary>
            <param name="kmlStyle">KML Style information.</param>
            <param name="geomElement">Linear ring geometry information.</param>
            <returns>A FeatureDescriptor object representing the feature.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ExtractPolyLine(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle,System.Xml.Linq.XElement)">
            <summary>
            Extracts a polyline from the input element and applies style information to the feature descriptor.
            </summary>
            <param name="kmlStyle">KML Style information.</param>
            <param name="line">Polyline geometry information.</param>
            <returns>A FeatureDescriptor object representing the feature.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ExtractPoint(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle,System.Xml.Linq.XElement)">
            <summary>
            Extracts a point from the input element and applies style information to the feature descriptor.
            </summary>
            <param name="kmlStyle">KML Style information.</param>
            <param name="point">Point geometry information.</param>
            <returns>A FeatureDescriptor object representing the feature.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ExtractRing(System.Xml.Linq.XElement)">
            <summary>
            Extracts a collection of points from a LinearRing definition.
            </summary>
            <param name="boundary">Outer or Inner boundary XElement object.</param>
            <returns>A PointCollection containing MapPoint objects.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ExtractCoordinates(System.Xml.Linq.XElement)">
            <summary>
            Extracts the X and Y values from a comma delimited string containing multiple coordinates.
            </summary>
            <param name="coordinates">Comma delimited string containing multiple coordinate groups.</param>
            <returns>A PointCollection containing MapPoint objects.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ExtractCoordinate(System.String)">
            <summary>
            Extracts the X and Y values from a comma delimited string containing a single coordinate.
            </summary>
            <param name="coordinate">Comma delimited string containing X, Y and Z values.</param>
            <returns>A MapPoint object with X and Y coordinate values assigned.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.GetStyle(System.Xml.Linq.XElement,ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle)">
            <summary>
            Constructs a KMLStyle object that represents KML style contained in the input XElement.
            </summary>
            <param name="style">XElement containing KML style definition.</param>
            <param name="kmlStyle">KMLStyle object representing input style.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.StringToBool(System.String)">
            <summary>
            Converts a string containing an integer value into a boolean.
            </summary>
            <param name="s">String containing boolean in numeric format.</param>
            <returns>Boolean value extracted from the input string.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.GetColorFromHexString(System.String)">
            <summary>
            Converts hexadecimal color notation into equivalent Silverlight Color.
            </summary>
            <param name="s">Input color string in hexadecimal format.</param>
            <returns>Color object representing input string.</returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.ProxyUrl">
            <summary>
            Optional. Gets or sets the URL to a proxy service that brokers Web requests between the Silverlight 
            client and a KML file.  Use a proxy service when the KML file is not hosted on a site that provides
            a cross domain policy file (clientaccesspolicy.xml or crossdomain.xml).
            </summary>
            <value>The Proxy URL string.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlToFeatureDefinition.DownloadStyleState">
            <summary>
            This stores the state of the currently processed KML feature while its style information is
            downloaded from an external source.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer">
            <summary>
            GeoRSS Layer.
            </summary>
            <remarks>
            <para>
            Only <a href="http://www.georss.org/simple">GeoRSS-simple</a> feeds are supported.
            Geometries are returned in Geographic WGS84. If you are displaying the feed
            on top of a map in a different projection, they must be reprojected manually 
            when the graphics collection gets features added.
            </para>
            <para>
            The graphic will not have a symbol associated with them. You should specify
            a renderer on this layer, or manually assign symbols to the graphics when
            the graphics collection gets features added.
            </para>
            <para>
            <example>
            Recent earthquake's greater than M2.5 with map tips:
            <code Lang="Xaml">
            &lt;esri:GeoRssLayer Source="http://earthquake.usgs.gov/earthquakes/catalogs/1day-M2.5.xml" &gt;
            	&lt;esri:GeoRssLayer.Renderer&gt;
            		&lt;esri:SimpleRenderer Brush="Red" /&gt;
            	&lt;/esri:GeoRssLayer.Renderer&gt;
            	&lt;esri:GeoRssLayer.MapTip&gt;
            		&lt;Border Padding="5" Background="White" esri:GraphicsLayer.MapTipHideDelay="0:0:0.5"&gt;
            			&lt;StackPanel&gt;
            				&lt;TextBlock Text="{Binding [Title]}" FontWeight="Bold" FontSize="12" /&gt;
            				&lt;TextBlock Text="{Binding [Summary]}" FontSize="10" /&gt;
            				&lt;HyperlinkButton Content="Link" NavigateUri="{Binding [Link]}" Opacity=".5" FontSize="10" TargetName="_blank" /&gt;
            			&lt;/StackPanel&gt;
            		&lt;/Border&gt;
            	&lt;/esri:GeoRssLayer.MapTip&gt;
            &lt;/esri:GeoRssLayer&gt;
            </code>
            </example>
            </para>
            <para>
            <example>
            If you require a proxy, simply prefix the layer URI with a proxy prefix:
            <code Lang="Xaml">
            &lt;esri:GeoRssLayer Source="../proxy.ashx?url=http://earthquake.usgs.gov/earthquakes/catalogs/1day-M2.5.xml" /&gt;
            </code>
            </example>
            </para>
            <para>
            The following attributes will be associated with each graphic:<br/>
            <list type="bullet">
            	<item>Title (<see cref="T:System.String"/>)</item>
            	<item>Summary (<see cref="T:System.String"/>)</item> 
            	<item>PublishDate (<see cref="T:System.DateTime"/>)</item>
            	<item>Id (<see cref="T:System.String"/>)</item>
            	<item>Link (<see cref="T:System.Uri"/>)</item>
            	<item>FeedItem (<see cref="T:System.ServiceModel.Syndication.SyndicationItem"/>)</item>
            </list>
            Optionally, if the item is using any of the simple-georss extensions,
            these will also be included: 
            <list type="bullet">
            	<item>elev (<see cref="T:System.Double"/>)</item>
            	<item>floor (<see cref="T:System.Int32"/>)</item>
            	<item>radius (<see cref="T:System.Double"/>)</item>
            	<item>featuretypetag (<see cref="T:System.String"/>)</item> 
            	<item>relationshiptag (<see cref="T:System.String"/>)</item>
            	<item>featurename (<see cref="T:System.String"/>)</item>
            </list>
            The Graphic's <see cref="P:ESRI.ArcGIS.Client.Graphic.TimeExtent"/> property 
            will be set to a time instance matching the PublishDate.
            </para>
            </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer.Initialize">
            <summary>
            Initializes the resource.
            </summary>
            <remarks>
            	<para>Override this method if your resource requires asyncronous requests to initialize,
            and call the base method when initialization is completed.</para>
            	<para>Upon completion of initialization, check the <see cref="P:ESRI.ArcGIS.Client.Layer.InitializationFailure"/> for any possible errors.</para>
            </remarks>
            <seealso cref="E:ESRI.ArcGIS.Client.Layer.Initialized"/>
            <seealso cref="P:ESRI.ArcGIS.Client.Layer.InitializationFailure"/>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer.SourceProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer.Source"/> dependency property.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer.Update">
            <summary>
            Reloads the RSS feed from the endpoint.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer.Credentials">
            <summary>
            Gets or sets the network credentials that are sent to the host and used to authenticate the request.
            </summary>
            <value>The credentials used for authentication.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.GeoRssLayer.Source">
            <summary>
            Gets or sets the URI for the RSS feed.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile">
            <summary>
            The ZipFile type represents a zip archive file.  This is the main type in the 
            DotNetZip class library.  This class reads and writes zip files, as defined in the format
            for zip described by PKWare.  The compression for this implementation was, at one time, based on the
            System.IO.Compression.DeflateStream base class in the .NET Framework
            base class library, available in v2.0 and later of the .NET Framework. As of v1.7 of DotNetZip,
            the compression is provided by a managed-code version of Zlib, included with DotNetZip. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.DefaultEncoding">
            <summary>
            The default text encoding used in zip archives.  It is numeric 437, also known as IBM437. 
            </summary>
            <seealso cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding">ProvisionalAlternateEncoding</seealso>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.#ctor">
             <summary>
             Create a zip file, without specifying a target filename or stream to save to. 
             </summary>
             
             <remarks>
             <para>
             See the documentation on the ZipFile(String) ZipFile constructor
             that accepts a single string argument for basic information on all the ZipFile constructors.
             </para>
            
             <para>
             After instantiating with this constructor and adding entries to the archive,
             your application should call ZipFile.Save(String) or ZipFile.Save(System.IO.Stream) to save to a file or a stream, respectively. 
             If you call the no-argument Save() method, the Save() will throw, as there is no 
             known place to save the file. 
             </para>
            
             <para>
             Instances of the ZipFile class are not multi-thread safe.  You may not party on a single
             instance with multiple threads.  You may have multiple threads that each use a distinct ZipFile 
             instance, or you can synchronize multi-thread access to a single instance.
             </para>
             
             </remarks>
             
             <example>
             This example creates a Zip archive called Backup.zip, containing all the files
             in the directory DirectoryToZip. Files within subdirectories are not zipped up.
             <code>
             using (ZipFile zip = new ZipFile())
             { 
               // Store all files found in the top level directory, into the zip archive.
               // note: this code does not recurse subdirectories!
               String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);
               foreach (String filename in filenames)
               {
                 Console.WriteLine("Adding {0}...", filename);
                 zip.AddFile(filename);
               }  
               zip.Save("Backup.zip");
             }
             </code>
            
             <code lang="VB">
             Using zip As New ZipFile
                 ' Store all files found in the top level directory, into the zip archive.
                 ' note: this code does not recurse subdirectories!
                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
                 Dim filename As String
                 For Each filename In filenames
                     Console.WriteLine("Adding {0}...", filename)
                     zip.AddFile(filename)
                 Next
                 zip.Save("Backup.zip")
             End Using
             </code>
             </example>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Read(System.IO.Stream)">
             <summary>
             Reads a zip archive from a stream.
             </summary>
            
             <remarks>
             <para>
             This is useful when when the zip archive content is available from 
             an already-open stream. The stream must be open and readable when calling this
             method.  The stream is left open when the reading is completed. 
             </para>
             <para>
             The stream is read using the default <c>System.Text.Encoding</c>, which is the <c>IBM437</c> codepage.  
             </para>
             </remarks>
            
             <example>
             This example shows how to Read zip content from a stream, and extract
             one entry into a different stream. In this example, the filename
             "NameOfEntryInArchive.doc", refers only to the name of the entry
             within the zip archive.  A file by that name is not created in the
             filesystem.  The I/O is done strictly with the given streams.
             <code>
             using (ZipFile zip = ZipFile.Read(InputStream))
             {
               zip.Extract("NameOfEntryInArchive.doc", OutputStream);
             }
             </code>
             <code lang="VB">
             Using zip as ZipFile = ZipFile.Read(InputStream)
               zip.Extract("NameOfEntryInArchive.doc", OutputStream)
             End Using
             </code>
             </example>
            
             <param name="zipStream">the stream containing the zip data.</param>
            
             <returns>an instance of ZipFile</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Read(System.IO.Stream,System.Text.Encoding)">
             <summary>
             Reads a zip archive from a stream, using the specified text Encoding, the 
             specified TextWriter for status messages, 
             and the specified ReadProgress event handler.
             </summary>
            
             <param name="zipStream">the stream containing the zip data.</param>
            
             <param name="encoding">
             The text encoding to use when reading entries that do not have the UTF-8 encoding
             bit set.  Be careful specifying the encoding.  If the value you use here is not the
             same as the Encoding used when the zip archive was created (possibly by a different
             archiver) you will get unexpected results and possibly exceptions.  See the
             ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding ProvisionalAlternateEncoding
             property for more information.
             </param>
             
             <returns>an instance of ZipFile</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Read(System.Byte[])">
            <summary>
            Reads a zip archive from a byte array.
            </summary>
            
            <remarks>
            This is useful when the data for the zipfile is contained in a byte array, 
            for example, downloaded from an FTP server without being saved to a
            filesystem. 
            </remarks>
            
            <param name="buffer">
            The byte array containing the zip data.  
            (I don't know why, but sometimes the compiled helpfuile (.chm) indicates a 2d 
            array when it is just one-dimensional.  This is a one-dimensional array.)
            </param>
            
            <returns>an instance of ZipFile. The name on the ZipFile will be null (nothing in VB)). </returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Read(System.Byte[],System.Text.Encoding)">
             <summary>
             Reads a zip archive from a byte array, using the given StatusMessageWriter and text Encoding.
             </summary>
             
             <remarks>
             <para>
             This method is useful when the data for the zipfile is contained in a byte array, for
             example when retrieving the data from a database or other non-filesystem store.  
             </para>
             
             </remarks>
             
             <param name="buffer">the byte array containing the zip data.</param>
            
             <param name="encoding">
             The text encoding to use when reading entries that do not have the UTF-8 encoding
             bit set.  Be careful specifying the encoding.  If the value you use here is not the
             same as the Encoding used when the zip archive was created (possibly by a different
             archiver) you will get unexpected results and possibly exceptions.  See the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/>
             property for more information.
             </param>
             
             <returns>an instance of ZipFile. The name is set to null.</returns>
             
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.GetEnumerator">
             <summary>
             Generic IEnumerator support, for use of a ZipFile in a foreach construct.  
             </summary>
            
             <remarks>
             You probably do not want to call <c>GetEnumerator</c> explicitly. Instead 
             it is implicitly called when you use a <c>foreach</c> loop in C#, or a 
             <c>For Each</c> loop in VB.
             </remarks>
            
             <example>
             This example reads a zipfile of a given name, then enumerates the 
             entries in that zip file, and displays the information about each 
             entry on the Console.
             <code>
             using (ZipFile zip = ZipFile.Read(zipfile))
             {
               bool header = true;
               foreach (ZipEntry e in zip)
               {
                 if (header)
                 {
                    System.Console.WriteLine("Zipfile: {0}", zip.Name);
                    System.Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded);
                    System.Console.WriteLine("BitField: 0x{0:X2}", e.BitField);
                    System.Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod);
                    System.Console.WriteLine("\n{1,-22} {2,-6} {3,4}   {4,-8}  {0}",
                                 "Filename", "Modified", "Size", "Ratio", "Packed");
                    System.Console.WriteLine(new System.String('-', 72));
                    header = false;
                 }
            
                 System.Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}",
                             e.FileName,
                             e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
                             e.UncompressedSize,
                             e.CompressionRatio,
                             e.CompressedSize);
            
                 e.Extract();
               }
             }
             </code>
            
             <code lang="VB">
               Dim ZipFileToExtract As String = "c:\foo.zip"
               Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)
                   Dim header As Boolean = True
                   Dim e As ZipEntry
                   For Each e In zip
                       If header Then
                           Console.WriteLine("Zipfile: {0}", zip.Name)
                           Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded)
                           Console.WriteLine("BitField: 0x{0:X2}", e.BitField)
                           Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod)
                           Console.WriteLine(ChrW(10) &amp; "{1,-22} {2,-6} {3,4}   {4,-8}  {0}", _
                             "Filename", "Modified", "Size", "Ratio", "Packed" )
                           Console.WriteLine(New String("-"c, 72))
                           header = False
                       End If
                       Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}", _
                         e.FileName, _
                         e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"), _
                         e.UncompressedSize, _
                         e.CompressionRatio, _
                         e.CompressedSize )
                       e.Extract
                   Next
               End Using
             </code>
             </example>
             
             <returns>A generic enumerator suitable for use  within a foreach loop.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            IEnumerator support, for use of a ZipFile in a foreach construct.  
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Extract(System.String,System.IO.Stream)">
             <summary>
             Extract a single specified file from the archive, to the given stream.   
             </summary>
             
             <remarks>
             <para>
             Calling this method, the entry is extracted using the Password that is 
             specified on the ZipFile instance. If you have not set the Password property, then
             the password is null, and the entry is extracted with no password.
             </para>
            
             <para>
             The ExtractProgress event is invoked before and after extraction, if it has been set. 
             </para>
             </remarks>
             
             <exception cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipException">
             Thrown if the outputStream is not writable, or if the filename is 
             null or empty. The inner exception is an ArgumentException in each case.
             </exception>
            
             <param name="fileName">
             the file to extract. It should include pathnames used in the archive, if any.
             The filename match is not case-sensitive by default; you can use the
             <c>CaseSensitiveRetrieval</c> property to change this behavior.The
             application can specify pathnames using forward-slashes or backward slashes.
             </param>
            
             <param name="outputStream">
             the stream to which the extacted, decompressed file data is written. 
             The stream must be writable.
             </param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Finalize">
            <summary>
            This is the class Destructor, which gets called implicitly when the instance is destroyed.  
            Because the ZipFile type implements IDisposable, this method calls Dispose(false).  
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Dispose">
            <summary>
            Handles closing of the read and write streams associated
            to the ZipFile, if necessary.  The Dispose() method is generally 
            employed implicitly, via a using() {} statement. 
            </summary>
            <example>
            <code>
            using (ZipFile zip = ZipFile.Read(zipfile))
            {
              foreach (ZipEntry e in zip)
              {
                if (WantThisEntry(e.FileName)) 
                  zip.Extract(e.FileName, Console.OpenStandardOutput());
              }
            } // Dispose() is called implicitly here.
            </code>
            </example>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Dispose(System.Boolean)">
            <summary>
            The Dispose() method.  It disposes any managed resources, 
            if the flag is set, then marks the instance disposed.
            This method is typically not called from application code.
            </summary>
            <param name="disposeManagedResources">indicates whether the method should dispose streams or not.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Comment">
             <summary>
             A comment attached to the zip archive.
             </summary>
            
             <remarks>
            
             <para>
             This property is read/write for the zipfile. It allows the application to
             specify a comment for the zipfile, or read the comment for the zipfile. 
             After setting this property, changes are only made permanent when you call a
             <c>Save()</c> method.
             </para>
            
             <para>
             According to the zip specification, the comment is not encrypted, even if there is a password
             set on the zip archive. 
             </para>
            
             <para>
             The zip spec does not describe how to encode the comment string in a code page other than IBM437. 
             Therefore, for "compliant" zip tools and libraries, comments will use IBM437.  However, there are
             situations where you want an encoded Comment, for example using code page 950 "Big-5 Chinese".
             DotNetZip will encode the comment in the code page specified by <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/>,
             at the time of the call to ZipFile.Save().
             </para>
            
             <para>
             When creating a zip archive using this library, it is possible to change the value of 
             <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/> between each entry you add, and between adding entries and the 
             call to Save(). Don't do this.  It will likely result in a zipfile that is not readable by 
             any tool or application. 
             For best interoperability, leave <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/> alone, or 
             specify it only once, before adding any entries to the ZipFile instance.
             </para>
            
             </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.CaseSensitiveRetrieval">
            <summary>
            Indicates whether to perform case-sensitive matching on the filename when retrieving
            entries in the zipfile via the string-based indexer.  
            </summary>
            <remarks>
            The default value is <c>false</c>,
            which means DON'T do case-sensitive matching. In other words, retrieving
            zip["ReadMe.Txt"] is the same as zip["readme.txt"].
            It really makes sense to set this to <c>true</c> only if you are not running on
            Windows, which has case-insensitive filenames. But since this library is not built for
            non-Windows platforms, in most cases you should just leave this property alone. 
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.UseUnicodeAsNecessary">
            <summary>
            Indicates whether to encode entry filenames and entry comments using Unicode 
            (UTF-8) according to the PKWare specification, for those filenames and comments
            that cannot be encoded in the IBM437 character set.
            </summary>
            <remarks>
            <para>
            The PKWare specification provides for encoding in either the IBM437 code page, or in UTF-8. 
            This flag selects the encoding according to that specification. 
            By default, this flag is false, and filenames and comments are encoded 
            into the zip file in the IBM437 codepage. 
            Setting this flag to true will specify that
            filenames and comments are encoded with UTF-8. 
            </para>
            <para>
            Zip files created with strict adherence to the PKWare specification
            with respect to UTF-8 encoding can contain entries with filenames containing
            any combination of Unicode characters, including the full 
            range of characters from Chinese, Latin, Hebrew, Greek, Cyrillic, and many 
            other alphabets. 
            However, because the UTF-8 portion of the PKWare specification is not broadly
            supported by other zip libraries and utilities, such zip files may not
            be readable by your favorite zip tool or archiver. In other words, interoperability
            will decrease if you set this flag to true. 
            </para>
            <para>
            In particular, Zip files created with strict adherence to the PKWare 
            specification with respect to UTF-8 encoding will not work well with 
            Explorer in Windows XP or Windows Vista, because Vista compressed folders 
            do not support UTF-8 in zip files.  Vista can read the zip files, but shows
            the filenames incorrectly.  Unpacking from Windows Vista Explorer will result in filenames
            that have rubbish characters in place of the high-order UTF-8 bytes.
            </para>
            <para>
            Also, zip files that use UTF-8 encoding will not work well 
            with Java applications that use the java.util.zip classes, as of 
            v5.0 of the Java runtime. The Java runtime does not correctly 
            implement the PKWare specification in this regard.
            </para>
            <para>
            As a result, we have the unfortunate situation that "correct" 
            behavior by the DotNetZip library with regard to Unicode during zip creation will result 
            in zip files that are readable by strictly compliant and current tools (for example the most 
            recent release of the commercial WinZip tool); but these zip files will
            not  be readable by various other tools or libraries, including Windows Explorer.
            </para>
            <para>
            The DotNetZip library can read and write zip files 
            with UTF8-encoded entries, according to the PKware spec.  If you use DotNetZip for both 
            creating and reading the zip file, and you use UTF-8, there will be no loss of information 
            in the filenames. For example, using a self-extractor created by this
            library will allow you to unpack files correctly with no loss of 
            information in the filenames. 
            </para>
            <para>
            Encoding filenames and comments using the IBM437 codepage, the default
            behavior, will cause loss of information on some filenames,
            but the resulting zipfile will
            be more interoperable with other utilities. As an example of the 
            loss of information, the o-tilde character will be down-coded to plain o. 
            Likewise, the O with a stroke through it, used in Danish and Norwegian,
            will be down-coded to plain o. Chinese characters cannot be represented
            in codepage IBM437; when using the default encoding, Chinese characters in 
            filenames will be represented as ?.  
            </para>
            <para>
            The loss of information associated to the use of the IBM437 encoding can lead to
            runtime errors. For example, using IBM437, any sequence of 4 Chinese characters will
            be encoded as ????.  If your application creates a ZipFile, then adds two files, each
            with names of four Chinese characters each, this will result in a duplicate filename
            exception.  In the case where you add a single file with a name containing four
            Chinese characters, calling Extract() on the entry that has question marks in the
            filename will result in an exception, because the question mark is not legal for use
            within filenames on Windows.  These are just a few examples of the problems associated
            to loss of information.
            </para>
            <para>
            This flag is independent of the encoding of the content within the 
            entries in the zip file.  
            </para>
            <para>
            Rather than specify the encoding in a binary fashion using this flag, an application
            can specify an arbitrary encoding via the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/> property.  Setting 
            the encoding explicitly when creating zip archives will result in non-compliant 
            zip files that, curiously, are fairly interoperable.  The challenge is, the PKWare specification
            does not provide for a way to specify that an entry in a zip archive uses a code page that is
            neither IBM437 nor UTF-8.   Therefore 
            if you set the encoding explicitly when creating a zip archive, you must take care upon 
            reading the zip archive to use the same code page.  If you get it wrong, the behavior is 
            undefined and may result in incorrect filenames, exceptions, stomach upset, hair loss, and acne.  
            </para>
            </remarks>
            <seealso cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding">ProvisionalAlternateEncoding</seealso>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding">
             <summary>
             The text encoding to use when writing new entries to the ZipFile, for those
             entries that cannot be encoded with the default (IBM437) encoding; or, the
             text encoding that was used when reading the entries from the ZipFile.
             </summary>
             
             <remarks>
             <para>
             In its AppNote.txt document, PKWare describes how to specify in the zip entry
             header that a filename or comment containing non-ANSI characters is encoded with
             UTF-8.  But, some archivers do not follow the specification, and instead encode
             super-ANSI characters using the system default code page.  For example, WinRAR
             when run on a machine in Shanghai may encode filenames with the Big-5 Chinese
             (950) code page.  This behavior is contrary to the Zip specification, but it
             occurs anyway.
             </para>
            
             <para>
             When using DotNetZip to write zip archives that will be read by one of these other
             archivers, set this property to specify the code page to use when encoding the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.FileName"/> and <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.Comment"/> for each ZipEntry in the zip file,
             for values that cannot be encoded with the default codepage for zip files, IBM437.
             This is why this property is "provisional".  In all cases, IBM437 is used where
             possible, in other words, where no loss of data would result. It is possible, therefore, to have a given 
             entry with a Comment encoded in IBM437 and a FileName encoded with the specified "provisional" codepage. 
             </para>
            
             <para>
             Be aware that a zip file created after you've explicitly set the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/> property to a value other than IBM437 may not be
             compliant to the PKWare specification, and may not be readable by compliant archivers.
             On the other hand, many (most?) archivers are non-compliant and can read zip files
             created in arbitrary code pages.  The trick is to use or specify the proper codepage
             when reading the zip.
             </para>
            
             <para>
             When creating a zip archive using this library, it is possible to change the value of
             <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/> between each entry you add, and between
             adding entries and the call to Save(). Don't do this. It will likely result in a
             zipfile that is not readable.  For best interoperability, either leave <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.ProvisionalAlternateEncoding"/> alone, or specify it only once, before adding
             any entries to the ZipFile instance.  There is one exception to this recommendation,
             described later.
             </para>
            
             <para>
             When using an arbitrary, non-UTF8 code page for encoding, there is no standard way for
             the creator application - whether DotNetZip, WinZip, WinRar, or something else - to
             formally specify in the zip file which codepage has been used for the entries. As a
             result, readers of zip files are not able to inspect the zip file and determine the
             codepage that was used for the entries contained within it.  It is left to the
             application or user to determine the necessary codepage when reading zipfiles encoded
             this way.  If you use an incorrect codepage when reading a zipfile, you will get
             entries with filenames that are incorrect, and the incorrect filenames may even contain
             characters that are not legal for use within filenames in Windows. Extracting entries
             with illegal characters in the filenames will lead to exceptions. It's too bad, but
             this is just the way things are with code pages in zip files. Caveat Emptor.
             </para>
            
             <para>
             When using DotNetZip to read a zip archive, and the zip archive uses an arbitrary code
             page, you must specify the encoding to use before or when the zipfile is READ.  This
             means you must use a ZipFile.Read() method that allows you to specify a
             System.Text.Encoding parameter.  Setting the ProvisionalAlternateEncoding property
             after your application has read in the zip archive will not affect the entry names of
             entries that have already been read in, and is probably not what you want.
             </para>
            	
             <para>
             And now, the exception to the rule described above.  One strategy for specifying the
             code page for a given zip file is to describe the code page in a human-readable form in
             the Zip comment. For example, the comment may read "Entries in this archive are encoded
             in the Big5 code page".  For maximum interoperability, the Zip comment in this case
             should be encoded in the default, IBM437 code page.  In this case, the zip comment is
             encoded using a different page than the filenames.  To do this, specify
             ProvisionalAlternateEncoding to your desired region-specific code page, once before
             adding any entries, and then reset ProvisionalAlternateEncoding to IBM437 before
             setting the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Comment"/> property and calling Save().
             </para>
             </remarks>
             
             <seealso cref="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.DefaultEncoding">DefaultEncoding</seealso>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Item(System.Int32)">
             <summary>
             This is an integer indexer into the Zip archive.
             </summary>
             
             <remarks>
             <para>
             This property is read-write. But don't get too excited: When setting the value, the
             only legal value is null. If you assign a non-null value
             (non Nothing in VB), the setter will throw an exception.
             </para>
            
             <para>
             Setting the value to null is equivalent to calling ZipFile.RemoveEntry(String)
             with the filename for the given entry.
             </para>
             </remarks>
             
             <exception cref="T:System.ArgumentException">
             Thrown if the caller attempts to assign a non-null value to the indexer, 
             or if the caller uses an out-of-range index value.
             </exception>
            
             <param name="ix">
             The index value.
             </param>
             
             <returns>
             The ZipEntry within the Zip archive at the specified index. If the 
             entry does not exist in the archive, this indexer throws.
             </returns>
             
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Item(System.String)">
             <summary>
             This is a name-based indexer into the Zip archive.  
             </summary>
             
             <remarks>
             <para>
             Retrieval by the string-based indexer is done on a case-insensitive basis, 
             by default.  Set the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.CaseSensitiveRetrieval"/> property to use case-sensitive 
             comparisons. 
             </para>
             <para>
             This property is read-write. When setting the value, the
             only legal value is null. Setting the value to null is
             equivalent to calling ZipFile.RemoveEntry(String) with the filename.
             </para>
             <para>
             If you assign a non-null value
             (non Nothing in VB), the setter will throw an exception.
             </para>
             <para>
             It is not always the case that <c>this[value].FileName == value</c>.  In
             the case of directory entries in the archive, you may retrieve them with
             the name of the directory with no trailing slash, even though in the
             entry itself, the actual <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.FileName"/> property may
             include a trailing slash.  In other words, for a directory entry named
             "dir1", you may find <c>this["dir1"].FileName == "dir1/"</c>.
             </para>
             </remarks>
             
             <example>
             This example extracts only the entries in a zip file that are .txt files.
             <code>
             using (ZipFile zip = ZipFile.Read("PackedDocuments.zip"))
             {
               foreach (string s1 in zip.EntryFilenames)
               {
                 if (s1.EndsWith(".txt"))
                   zip[s1].Extract("textfiles");
               }
             }
             </code>
             <code lang="VB">
               Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip")
                   Dim s1 As String
                   For Each s1 In zip.EntryFilenames
                       If s1.EndsWith(".txt") Then
                           zip(s1).Extract("textfiles")
                       End If
                   Next
               End Using
             </code>
             </example>
            
             <exception cref="T:System.ArgumentException">
             Thrown if the caller attempts to assign a non-null value to the indexer.
             </exception>
            
             <param name="fileName">
             The name of the file, including any directory path, to retrieve from the zip. 
             The filename match is not case-sensitive by default; you can use the
             <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.CaseSensitiveRetrieval"/> property to change this behavior. The
             pathname can use forward-slashes or backward slashes.
             </param>
             
             <returns>
             The ZipEntry within the Zip archive, given by the specified filename. If the named
             entry does not exist in the archive, this indexer returns null.
             </returns>
             
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.EntryFileNames">
             <summary>
             The list of filenames for the entries contained within the zip archive.  The 
             filenames use forward slashes in pathnames. 
             </summary>
            
             <seealso cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Item(System.String)"/>
            
             <example>
             This example shows one way to test if a filename is already contained within 
             a zip archive.
             <code>
             String ZipFileToRead= "PackedDocuments.zip";
             string Candidate = "DatedMaterial.xps";
             using (ZipFile zip = new ZipFile(ZipFileToRead))
             {
               if (zip.EntryFilenames.Contains(Candidate))
                 Console.WriteLine("The file '{0}' exists in the zip archive '{1}'",
                                   Candidate,
                                   ZipFileName);
               else
                 Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'",
                                   Candidate,
                                   ZipFileName);
               Console.WriteLine();
             }
             </code>
             <code lang="VB">
               Dim ZipFileToRead As String = "PackedDocuments.zip"
               Dim Candidate As String = "DatedMaterial.xps"
               Using zip As New ZipFile(ZipFileToRead)
                   If zip.EntryFilenames.Contains(Candidate) Then
                       Console.WriteLine("The file '{0}' exists in the zip archive '{1}'", _
                                   Candidate, _
                                   ZipFileName)
                   Else
                     Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'", _
                                   Candidate, _
                                   ZipFileName)
                   End If
                   Console.WriteLine
               End Using
             </code>
             </example>
            
             <returns>
             The list of strings for the filenames contained within the Zip archive.
             </returns>
             
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Entries">
            <summary>
            Returns the readonly collection of entries in the Zip archive.
            </summary>
            <remarks>
            If there are no entries in the current ZipFile, the value returned is a non-null zero-element collection.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile.Count">
            <summary>
            Returns the number of entries in the Zip archive.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.Zip64Option">
            <summary>
            Options for using ZIP64 extensions when saving zip archives. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.Zip64Option.Default">
            <summary>
            The default behavior, which is "Never".
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.Zip64Option.Never">
            <summary>
            Do not use ZIP64 extensions when writing zip archives.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.Zip64Option.AsNecessary">
            <summary>
            Use ZIP64 extensions when writing zip archives, as necessary. 
            For example, when a single entry exceeds 0xFFFFFFFF in size, or when the archive as a whole 
            exceeds 0xFFFFFFFF in size, or when there are more than 65535 entries in an archive.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.Zip64Option.Always">
            <summary>
            Always use ZIP64 extensions when writing zip archives, even when unnecessary.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EncryptionAlgorithm">
            <summary>
            An enum that provides the various encryption algorithms supported by this library.
            </summary>
            <remarks>
            <para>
            PkzipWeak implies the use of Zip 2.0 encryption, which is known to be weak and subvertible. 
            </para>
            <para>
            A note on interoperability: Values of PkzipWeak and None are specified in the PKWare AppNote.txt document, are 
            considered to be "standard".  Zip archives produced using these options will be interoperable with many other
            zip tools and libraries, including Windows Explorer.
            </para>
            <para>
            Values of WinZipAes128 and WinZipAes256 are not part of the Zip specification, but rather imply the use of a 
            vendor-specific extension from WinZip. If you want to produce interoperable Zip archives, do not use these values. 
            For example, if you
            produce a zip archive using WinZipAes256, you will be able to open it in Windows Explorer on Windows XP and Vista, 
            but you will not be able to extract entries; trying this will lead to an "unspecified error". For this reason, 
            some people have said that a zip archive that uses WinZip's AES encryption is not actually a zip archive at all.
            A zip archive produced this way will be readable with the WinZip tool
            (Version 11 and beyond).
            </para>
            <para>
            There are other third-party tools and libraries, both commercial and otherwise, that support WinZip's 
            AES encryption. These will be able to read AES-encrypted zip archives produced by DotNetZip, and conversely applications 
            that use DotNetZip to read zip archives will be able to read AES-encrypted archives produced by those tools
            or libraries.  Consult the documentation for those other tools and libraries to find out if WinZip's AES 
            encryption is supported. 
            </para>
            <para>
            In case you care: According to the WinZip specification, the actual key used is derived from the 
            ZipEntry.Password via an algorithm that complies with RFC 2898, using an iteration count of 1000.
            I am no security expert, but I think you should use a long-ish password if you employ 256-bit AES
            encryption.  Make it 16 characters or more.  
            </para>
            <para>
            The WinZip AES algorithms are not supported with the version of DotNetZip that runs on the .NET Compact Framework. 
            This is because .NET CF lacks the HMACSHA1 class that is required for producing the archive.
            </para>
            </remarks>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EncryptionAlgorithm.None">
            <summary>
            No encryption at all.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EncryptionAlgorithm.PkzipWeak">
            <summary>
            Traditional or Classic pkzip encryption.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EntrySource">
            <summary>
            An enum that specifies the source of the ZipEntry. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EntrySource.None">
            <summary>
            Default value.  Invalid on a bonafide ZipEntry.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EntrySource.Filesystem">
            <summary>
            Entry was instantiated by Adding an entry from the filesystem.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EntrySource.Zipfile">
            <summary>
            Entry was instantiated by reading a zipfile.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.EntrySource.Stream">
            <summary>
            Entry was instantiated via a stream or string.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry">
            <summary>
            Represents a single entry in a ZipFile. Typically, applications
            get a ZipEntry by enumerating the entries within a ZipFile,
            or by adding an entry to a ZipFile.  
            </summary>
            <summary>
            This class models an entry in the directory contained within the zip file.
            The class is generally not used from within application code, though it is
            used by the ZipFile class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.Read(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile,System.Boolean)">
            <summary>
            Reads one ZipEntry from the given stream.  If the entry is encrypted, we don't
            decrypt at this point.  We also do not decompress.  Mostly we read metadata.
            </summary>
            <param name="zf">the zipfile this entry belongs to.</param>
            <param name="first">true of this is the first entry being read from the stream.</param>
            <returns>the ZipEntry read from the stream.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.Extract(System.IO.Stream)">
            <summary>
            Extracts the entry to the specified stream. 
            </summary>
            
            <remarks>
            
            <para>
            For example, the caller could specify Console.Out, or a MemoryStream.
            </para>
            
            </remarks>
            
            <param name="stream">the stream to which the entry should be extracted.  </param>
            
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.ReadDirEntry(System.IO.Stream,System.Text.Encoding)">
            <summary>
            Reads one entry from the zip directory structure in the zip file. 
            </summary>
            <param name="s">the stream from which to read.</param>
            <param name="expectedEncoding">
            The text encoding to use if the entry is not marked UTF-8.
            </param>
            <returns>the entry read from the archive.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.IsNotValidZipDirEntrySig(System.Int32)">
            <summary>
            Returns true if the passed-in value is a valid signature for a ZipDirEntry. 
            </summary>
            <param name="signature">the candidate 4-byte signature value.</param>
            <returns>true, if the signature is valid according to the PKWare spec.</returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.LastModified">
             <summary>
             The time and date at which the file indicated by the ZipEntry was last modified. 
             </summary>
             
             <remarks>
             <para>
             The DotNetZip library sets the LastModified value for an entry, equal to the 
             Last Modified time of the file in the filesystem.  If an entry is added from a stream, 
             in which case no Last Modified attribute is available, the library uses 
             <c>System.DateTime.Now</c> for this value, for the given entry. 
             </para>
            
             <para>
             It is also possible to set the LastModified value on an entry, to an arbitrary
             value.  Be aware that because of the way the PKZip specification describes how
             times are stored in the zip file, the full precision of the
             <c>System.DateTime</c> datatype is not stored in LastModified when saving zip
             files.  For more information on how times are formatted, see the PKZip
             specification.
             </para>
            
             <para>
             The last modified time of the file created upon a call to <c>ZipEntry.Extract()</c> 
             may be adjusted during extraction to compensate
             for differences in how the .NET Base Class Library deals
             with daylight saving time (DST) versus how the Windows
             filesystem deals with daylight saving time. 
             See http://blogs.msdn.com/oldnewthing/archive/2003/10/24/55413.aspx for more context.
             </para>
             <para>
             In a nutshell: Daylight savings time rules change regularly.  In
             2007, for example, the inception week of DST changed.  In 1977,
             DST was in place all year round. In 1945, likewise.  And so on.
             Win32 does not attempt to guess which time zone rules were in
             effect at the time in question.  It will render a time as
             "standard time" and allow the app to change to DST as necessary.
              .NET makes a different choice.
             </para>
             <para>
             Compare the output of FileInfo.LastWriteTime.ToString("f") with
             what you see in the Windows Explorer property sheet for a file that was last
             written to on the other side of the DST transition. For example,
             suppose the file was last modified on October 17, 2003, during DST but
             DST is not currently in effect. Explorer's file properties
             reports Thursday, October 17, 2003, 8:45:38 AM, but .NETs
             FileInfo reports Thursday, October 17, 2003, 9:45 AM.
             </para>
             <para>
             Win32 says, "Thursday, October 17, 2002 8:45:38 AM PST". Note:
             Pacific STANDARD Time. Even though October 17 of that year
             occurred during Pacific Daylight Time, Win32 displays the time as
             standard time because that's what time it is NOW.
             </para>
             <para>
             .NET BCL assumes that the current DST rules were in place at the
             time in question.  So, .NET says, "Well, if the rules in effect
             now were also in effect on October 17, 2003, then that would be
             daylight time" so it displays "Thursday, October 17, 2003, 9:45
             AM PDT" - daylight time.
             </para>
             <para>
             So .NET gives a value which is more intuitively correct, but is
             also potentially incorrect, and which is not invertible. Win32
             gives a value which is intuitively incorrect, but is strictly
             correct.
             </para>
             <para>
             Because of this funkiness, this library adds one hour to the LastModified time
             on the extracted file, if necessary.  That is to say, if the time in question
             had occurred in what the .NET Base Class Library assumed to be DST (an
             assumption that may be wrong given the constantly changing DST rules).
             </para>
             </remarks>
            
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.LocalFileName">
            <summary>
            The name of the filesystem file, referred to by the ZipEntry. 
            </summary>
            
            <remarks>
            <para>
            This may be different than the path used in the archive itself. What I mean is, 
            if you call <c>Zip.AddFile("fooo.txt", AlternativeDirectory)</c>, then the 
            path used for the ZipEntry within the zip archive will be different than this path.  
            This path is used to locate the thing-to-be-zipped on disk. 
            </para>
            <para>
            If the entry is being added from a stream, then this is null (Nothing in VB).
            </para>
            
            </remarks>
            <seealso cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.FileName"/>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.FileName">
             <summary>
             The name of the file contained in the ZipEntry. 
             </summary>
             
             <remarks>
             <para>
             When writing a zip, this path has backslashes replaced with 
             forward slashes, according to the zip spec, for compatibility
             with Unix(tm) and ... get this.... Amiga!
             </para>
            
             <para>
             This is the name of the entry in the ZipFile itself.  This name may be different
             than the name of the filesystem file used to create the entry (LocalFileName). In fact, there
             may be no filesystem file at all, if the entry is created from a stream or a string.
             </para>
            
             <para>
             When setting this property, the value is made permanent only after a call to one of the ZipFile.Save() methods 
             on the ZipFile that contains the ZipEntry. By reading in a ZipFile, then explicitly setting the FileName on an
             entry contained within the ZipFile, and then calling Save(), you will effectively rename the entry within 
             the zip archive.
             </para>
             </remarks>
             <seealso cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.LocalFileName"/>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.VersionNeeded">
            <summary>
            The version of the zip engine needed to read the ZipEntry.  
            </summary>
            <remarks>
            This is usually 0x14. 
            (Decimal 20). If ZIP64 is in use, the version will be decimal 45.  
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.Comment">
             <summary>
             The comment attached to the ZipEntry. 
             </summary>
            
             <remarks>
             By default, the Comment is encoded in IBM437 code page. You can specify 
             an alternative with <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.ProvisionalAlternateEncoding"/>
             </remarks>
             <seealso cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.ProvisionalAlternateEncoding">ProvisionalAlternateEncoding</seealso>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.BitField">
             <summary>
             The bitfield as defined in the zip spec. You probably never need to look at this.
             </summary>
            
             <remarks>
             <code>
             bit  0 - set if encryption is used.
             b. 1-2 - set to determine whether normal, max, fast deflation.  
                      This library always leaves these bits unset when writing (indicating 
                      "normal" deflation").
            
             bit  3 - indicates crc32, compressed and uncompressed sizes are zero in
                      local header.  We always leave this as zero on writing, but can read
                      a zip with it nonzero. 
            
             bit  4 - reserved for "enhanced deflating". This library doesn't do enhanced deflating.
             bit  5 - set to indicate the zip is compressed patched data.  This library doesn't do that.
             bit  6 - set if strong encryption is used (must also set bit 1 if bit 6 is set)
             bit  7 - unused
             bit  8 - unused
             bit  9 - unused
             bit 10 - unused
             Bit 11 - Language encoding flag (EFS).  If this bit is set,
                      the filename and comment fields for this file
                      must be encoded using UTF-8. This library currently does not support UTF-8.
             Bit 12 - Reserved by PKWARE for enhanced compression.
             Bit 13 - Used when encrypting the Central Directory to indicate 
                      selected data values in the Local Header are masked to
                      hide their actual values.  See the section describing 
                      the Strong Encryption Specification for details.
             Bit 14 - Reserved by PKWARE.
             Bit 15 - Reserved by PKWARE.
             </code>
             </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.CompressionMethod">
            <summary>
            The compression method employed for this ZipEntry. 
            </summary>
            
            <remarks>
            <para>
            The ZIP specification allows a variety of compression methods.  This library 
            supports just two:  0x08 = Deflate.  0x00 = Store (no compression).  
            </para>
            
            <para>
            When reading an entry from an existing zipfile, the value you retrieve here
            indicates the compression method used on the entry by the original creator of the zip.  
            When writing a zipfile, you can specify either 0x08 (Deflate) or 0x00 (None).  If you 
            try setting something else, you will get an exception.  
            </para>
            
            <para>
            You may wish to set CompressionMethod to 0 (None) when zipping previously compressed
            data like a jpg, png, or mp3 file.  This can save time and cpu cycles.
            Setting CompressionMethod to 0 is equivalent to setting ForceNoCompression to true. 
            </para>
            
            <para>
            When updating a ZipFile, you may not modify the CompressionMethod on an entry that has been encrypted. 
            In other words, if you read an existing ZipFile with one of the ZipFile.Read() methods, and then 
            change the CompressionMethod on an entry that has Encryption not equal to None, you will receive an exception. 
            There is no way to modify the compression on an encrypted entry, without extracting it and re-adding it 
            into the ZipFile.  
            </para>
            </remarks>
            
            <example>
            In this example, the first entry added to the zip archive uses 
            the default behavior - compression is used where it makes sense.  
            The second entry, the MP3 file, is added to the archive without being compressed.
            <code>
            using (ZipFile zip = new ZipFile(ZipFileToCreate))
            {
              ZipEntry e1= zip.AddFile(@"c:\temp\Readme.txt");
              ZipEntry e2= zip.AddFile(@"c:\temp\StopThisTrain.mp3");
              e2.CompressionMethod = 0;
              zip.Save();
            }
            </code>
            
            <code lang="VB">
            Using zip as new ZipFile(ZipFileToCreate)
              zip.AddFile("c:\temp\Readme.txt")
              Dim e2 as ZipEntry = zip.AddFile("c:\temp\StopThisTrain.mp3")
              e2.CompressionMethod = 0
              zip.Save
            End Using
            </code>
            </example>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.CompressedSize">
            <summary>
            The compressed size of the file, in bytes, within the zip archive. 
            </summary>
            <remarks>
            The compressed size is computed during compression. This means that it is only
            valid to read this AFTER reading in an existing zip file, or AFTER saving a
            zipfile you are creating.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.UncompressedSize">
            <summary>
            The size of the file, in bytes, before compression, or after extraction. 
            </summary>
            <remarks>
            This property is valid AFTER reading in an existing zip file, or AFTER saving the 
            ZipFile that contains the ZipEntry.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.CompressionRatio">
             <summary>
             The ratio of compressed size to uncompressed size of the ZipEntry.
             </summary>
             
             <remarks>
             <para>
             This is a ratio of the compressed size to the uncompressed size of the entry,
             expressed as a double in the range of 0 to 100+. A value of 100 indicates no
             compression at all.  It could be higher than 100 when the compression algorithm
             actually inflates the data.
             </para>
            
             <para>
             You could format it for presentation to a user via a format string of "{3,5:F0}%"
             to see it as a percentage. 
             </para>
            
             <para>
             If the size of the original uncompressed file is 0, (indicating a denominator of 0)
             the return value will be zero. 
             </para>
            
             <para>
             This property is valid AFTER reading in an existing zip file, or AFTER saving the 
             ZipFile that contains the ZipEntry.
             </para>
            
             </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.Crc32">
            <summary>
            The CRC (Cyclic Redundancy Check) on the contents of the ZipEntry. 
            </summary>
            
            <remarks>
            You probably don't need to concern yourself with this. The CRC is generated according
            to the algorithm described in the Pkzip specification. It is a read-only property;
            when creating a Zip archive, the CRC for each entry is set only after a call to
            Save() on the containing ZipFile.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.IsDirectory">
            <summary>
            True if the entry is a directory (not a file). 
            This is a readonly property on the entry.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.UsesEncryption">
            <summary>
            A derived property that is <c>true</c> if the entry uses encryption.  
            </summary>
            <remarks>
            This is a readonly property on the entry.
            Upon reading an entry, this bool is determined by
            the data read.  When writing an entry, this bool is
            determined by whether the Encryption property is set to something other than
            EncryptionAlgorithm.None. 
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.Encryption">
             <summary>
             Set this to specify which encryption algorithm to use for the entry.
             </summary>
             
             <remarks>
             <para>
             When setting this property, you must also set a Password on the entry.  The set of
             algorithms supported is determined by the authors of this library.  The PKZIP
             specification from PKWare defines a set of encryption algorithms, and the data formats
             for the zip archive that support them. Other vendors of tools and libraries, such as
             WinZip or Xceed, also specify and support different encryption algorithms and data
             formats.
             </para>
            
             <para>
             There is no common, ubiquitous multi-vendor standard for strong encryption. There is
             broad support for "traditional" Zip encryption, sometimes called Zip 2.0 encryption,
             as specified by PKWare, but this encryption is considered weak. This library currently
             supports AES 128 and 256 in addition to the Zip 2.0 "weak" encryption.
             </para>
            
             <para>
             The WinZip AES encryption algorithms are not supported on the .NET Compact Framework. 
             </para>
             </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.UseUnicodeAsNecessary">
            <summary>
            Set to indicate whether to use UTF-8 encoding on filenames and 
            comments, according to the PKWare specification.  
            </summary>
            <remarks>
            If this flag is set, the entry will be marked as encoded with UTF-8, 
            according to the PWare spec, if necessary.  Necessary means, if the filename or 
            entry comment (if any) cannot be reflexively encoded with the default (IBM437) code page. 
            </remarks>
            <remarks>
            Setting this flag to true is equivalent to setting <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.ProvisionalAlternateEncoding"/> to <c>System.Text.Encoding.UTF8</c>
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.ProvisionalAlternateEncoding">
             <summary>
             The text encoding to use for this ZipEntry, when the default
             encoding is insufficient.
             </summary>
            
             <remarks>
             <para>
             According to the zip specification from PKWare, filenames and comments for a
             ZipEntry are encoded either with IBM437 or with UTF8.  But, some archivers do not
             follow the specification, and instead encode characters using the system default
             code page, or an arbitrary code page.  For example, WinRAR when run on a machine in
             Shanghai may encode filenames with the Chinese (Big-5) code page.  This behavior is
             contrary to the Zip specification, but it occurs anyway.  This property exists to
             support that non-compliant behavior when reading or writing zip files.
             </para>
             <para>
             When writing zip archives that will be read by one of these other archivers, use this property to 
             specify the code page to use when encoding filenames and comments into the zip
             file, when the IBM437 code page will not suffice.
             </para>
             <para>
             Be aware that a zip file created after you've explicitly specified the code page will not 
             be compliant to the PKWare specification, and may not be readable by compliant archivers. 
             On the other hand, many archivers are non-compliant and can read zip files created in 
             arbitrary code pages. 
             </para>
             <para>
             When using an arbitrary, non-UTF8 code page for encoding, there is no standard way for the 
             creator (DotNetZip) to specify in the zip file which code page has been used. DotNetZip is not
             able to inspect the zip file and determine the codepage used for the entries within it. Therefore, 
             you, the application author, must determine that.  If you use a codepage which results in filenames
             that are not legal in Windows, you will get exceptions upon extract. Caveat Emptor.
             </para>
             </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.ActualEncoding">
            <summary>
            The text encoding actually used for this ZipEntry.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipEntry.AttributesIndicateDirectory">
            <summary>
            True if the referenced entry is a directory.  
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer">
            <summary>
            OpenStreetMap tiled layer.
            </summary>
            <remarks>
            <para>This sample shows how to create your own custom tiled layer.</para>
            <para>To use it, first include OpenStreetMapLayer.cs in your Silverlight application.</para>
            <para>Next add the OSM layer in a map by adding it to the layers collection:</para>
            <example>
            <code language="XAML">
            &lt;esri:Map x:Name="map"&gt;
            	&lt;esri:Map.Layers&gt;
            		&lt;samples:OpenStreetMapLayer ID="OSM" xmlns:dataSources="clr-namespace:ESRI.ArcGIS.Client.Toolkit.DataSources" /&gt;
            	&lt;/esri:Map.Layers&gt;
            &lt;/esri:Map&gt;
            </code>
            </example>
            <para>Please read the usage guidelines for using OpenStreetMapLayer in your 
            application at http://www.openstreetmap.org.</para>
            <para>OpenStreetMap is released under the Create Commons 
            "Attribution-Share Alike 2.0 Generic" license.</para>
            </remarks>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.cornerCoordinate">
            <summary>Simple constant used for full extent and tile origin specific to this projection.</summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.WKID">
            <summary>ESRI Spatial Reference ID for Web Mercator.</summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.subDomains">
            <summary>Available subdomains for tiles.</summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.baseUrl">
            <summary>Base URL used in GetTileUrl.</summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.Initialize">
            <summary>
            Initializes the resource.
            </summary>
            <remarks>
            	<para>Override this method if your resource requires asyncronous requests to initialize,
            and call the base method when initialization is completed.</para>
            	<para>Upon completion of initialization, check the <see cref="P:ESRI.ArcGIS.Client.Layer.InitializationFailure"/> for any possible errors.</para>
            </remarks>
            <seealso cref="E:ESRI.ArcGIS.Client.Layer.Initialized"/>
            <seealso cref="P:ESRI.ArcGIS.Client.Layer.InitializationFailure"/>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.GetTileUrl(System.Int32,System.Int32,System.Int32)">
            <summary>
            Returns a url to the specified tile
            </summary>
            <param name="level">Layer level</param>
            <param name="row">Tile row</param>
            <param name="col">Tile column</param>
            <returns>URL to the tile image</returns>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.StyleProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.Style"/> dependency property.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.Style">
            <summary>
            Gets or sets the map style.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.MapStyle">
            <summary>
            MapStyle
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.MapStyle.Mapnik">
            <summary>
            Mapnik
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.MapStyle.Osmarender">
            <summary>
            Osmarender
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.MapStyle.CycleMap">
            <summary>
            Cycle Map
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer.MapStyle.NoName">
            <summary>
            No Name
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer">
            <summary>
            Extracts features from KML source and render as a graphics layer.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.Initialize">
            <summary>
            Initializes the resource.
            </summary>
            <seealso cref="E:ESRI.ArcGIS.Client.Layer.Initialized"/>
            <seealso cref="P:ESRI.ArcGIS.Client.Layer.InitializationFailure"/>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.SetSource(System.IO.Stream)">
            <summary>
            Sets the KML stream source.
            </summary>
            <param name="stream">A stream to a KML or KMZ file.</param>
            <remarks>
            Use this method if you need to load KML from a local file or
            file stream.
            </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.AddNetworkLink(System.String)">
            <summary>
            Attempt to add a network link href to the list of those that require processing. This list
            cannot handle more than 10 files for a given KML layer and will silently ignore an HREF once
            this limitation has been met.
            </summary>
            <param name="href">Reference to KML/KMZ file to be processed.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.GetNetworkLink">
            <summary>
            Returns the oldest HREF for a network link that was added to this list, if any.
            </summary>
            <returns>A network link HREF or null if none exist in the list.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.DownloadContent(System.Uri)">
            <summary>
            Download content using URL. This method may be called recursively if the KML file contains
            a network link.
            </summary>
            <param name="url">Location of KML content.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.webclient_OpenReadCompleted(System.Object,System.Net.OpenReadCompletedEventArgs)">
            <summary>
            Event handler for when the KML file is completely downloaded. If the KML content contains a
            network link, then the linked content will be downloaded recursively. If no network link is
            detected, then the KML content is converted into a feature definition using the engine and
            eventually rendered as graphic features.
            </summary>
            <param name="sender">Sending object.</param>
            <param name="e">Stream containing KML content.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.GetKmzContents(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipFile)">
            <summary>
            Processes each file in the ZIP stream, storing images in a dictionary and load the KML contents
            into an XDocument.
            </summary>
            <param name="zipFile">Decompressed stream from KMZ.</param>
            <returns>XDocument containing KML content from the KMZ source.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.GetDocumentNamespace(System.Xml.Linq.XDocument)">
            <summary>
            Extracts namespace value from KML file.
            </summary>
            <param name="xDoc">KML document which may define a namespace.</param>
            <returns>Namespace value which is used for LINQ queries.</returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.Credentials">
            <summary>
            Gets or sets the network credentials that are sent to the host and used to authenticate the request.
            </summary>
            <value>The credentials used for authentication.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.Url">
            <summary>
            Gets or sets the Url to the KML document.
            </summary>
            <seealso cref="M:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.SetSource(System.IO.Stream)"/>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer.ProxyUrl">
            <summary>
            Optional. Gets or sets the URL to a proxy service that brokers Web requests between the Silverlight 
            client and a KML file.  Use a proxy service when the KML file is not hosted on a site that provides
            a cross domain policy file (clientaccesspolicy.xml or crossdomain.xml).
            </summary>
            <value>The Proxy URL string.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer">
            <summary>
            A layer for OGC Web Map Services.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.Initialize">
            <summary>
            Initializes this a WMS layer.  Calls GetCapabilities if SkipGetCapabilities is false. 
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.GetUrl(ESRI.ArcGIS.Client.Geometry.Envelope,System.Int32,System.Int32,ESRI.ArcGIS.Client.DynamicMapServiceLayer.OnUrlComplete)">
            <summary>
            Gets the URL. Override from DynamicMapServiceLayer
            </summary>
            <param name="extent">The extent.</param>
            <param name="width">The width.</param>
            <param name="height">The height.</param>
            <param name="onComplete">OnUrlComplete delegate.</param>
            <remarks>
            The Map has a private method loadLayerInView which calls Layer.Draw.   
            The DynamicMapServiceLayer abstract class overrides the Draw method and calls 
            DynamicMapServiceLayer.GetUrl which must be implemented in a subclass.   
            The last parameter is the OnUrlComplete delegate, which is used to pass the appropriate values 
            (url, width, height, envelope) to the private DynamicMapServiceLayer.getUrlComplete method.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.Credentials">
            <summary>
            Gets or sets the network credentials that are sent to the host and used to authenticate the request.
            </summary>
            <value>The credentials used for authentication.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.Url">
            <summary>
            Required.  Gets or sets the URL to a WMS service endpoint.  
            For example, 
            http://sampleserver1.arcgisonline.com/ArcGIS/services/Specialty/ESRI_StatesCitiesRivers_USA/MapServer/WMSServer,
            http://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0r.cgi.
            </summary>
            <value>The URL.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.Layers">
            <summary>
            Required. Gets or sets the unique layer ids in a WMS service.  
            Each id is a string value.  At least one layer id must be defined.   
            </summary>
            <value>A string array of layer ids.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.ProxyUrl">
            <summary>
            Optional. Gets or sets the URL to a proxy service that brokers Web requests between the Silverlight 
            client and a WMS service.  Use a proxy service when the WMS service is not hosted on a site that provides
            a cross domain policy file (clientaccesspolicy.xml or crossdomain.xml).  You can also use a proxy to
            convert png images to a bit-depth that supports transparency in Silverlight.  
            </summary>
            <value>The proxy URL string.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.Version">
            <summary>
            Optional. Gets or sets the WMS version.  If SkipGetCapabilities property is set to true, this value determines version requested.  
            If SkipGetCapabilities is false, this value determines version to retrieve.  If no value specified, default value returned from 
            the site will be used.
            </summary>
            <value>The version string.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.SkipGetCapabilities">
            <summary>
            Optional. Gets or sets a value indicating whether to skip a request to get capabilities. 
            Default value is false.  Set SkipGetCapabilities if the site hosting the WMS service does not provide a
            cross domain policy file and you do not have a proxy page.  In this case, you must set the WMS service version.
            If true, the initial and full extent of the WMS Silverlight layer will not be defined.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.Title">
            <summary>
            Gets the title metadata for this service.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.Abstract">
            <summary>
            Gets the abstract metadata for this service.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.LayerList">
            <summary>
            Gets a list of layers available in this service.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.LayerInfo">
            <summary>
            WMS LayerInfo
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.LayerInfo.Name">
            <summary>
            Gets the name of the layer.
            </summary>
            <value>The name.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.LayerInfo.Title">
            <summary>
            Gets the title of the layer.
            </summary>
            <value>The title.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.LayerInfo.Abstract">
            <summary>
            Gets the abstract for the layer.
            </summary>
            <value>The abstract.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.LayerInfo.Extent">
            <summary>
            Gets the extent of the layer.
            </summary>
            <value>The extent.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.WmsLayer.LayerInfo.ChildLayers">
            <summary>
            Gets the child layers.
            </summary>
            <value>The child layers.</value>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants">
            <summary>
            A bunch of constants used in the Zlib interface.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_NO_FLUSH">
            <summary>
            No flush at all.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_PARTIAL_FLUSH">
            <summary>
            A little bit of flush?
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_SYNC_FLUSH">
            <summary>
            Sync flush?
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_FULL_FLUSH">
            <summary>
            Full flush?
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_FINISH">
            <summary>
            Finish?
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.WINDOW_BITS_MAX">
            <summary>
            The maximum number of window bits for the Deflate algorithm.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.WINDOW_BITS_DEFAULT">
            <summary>
            The default number of window bits for the Deflate algorithm.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_OK">
            <summary>
            indicates everything is A-OK
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_STREAM_END">
            <summary>
            Indicates that the last operation reached the end of the stream.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_NEED_DICT">
            <summary>
            The operation ended in need of a dictionary. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_STREAM_ERROR">
            <summary>
            There was an error with the stream - not enough data, not open and readable, etc.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_DATA_ERROR">
            <summary>
            There was an error with the data - not enough data, bad data, etc.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibConstants.Z_BUF_ERROR">
            <summary>
            There was an error with the working buffer.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CRC32">
            <summary>
            Calculates a 32bit Cyclic Redundancy Checksum (CRC) using the
            same polynomial used by Zip. This type is used internally by DotNetZip; it is generally not used directly
            by applications wishing to create, read, or manipulate zip archive files.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CRC32.GetCrc32(System.IO.Stream)">
            <summary>
            Returns the CRC32 for the specified stream.
            </summary>
            <param name="input">The stream over which to calculate the CRC32</param>
            <returns>the CRC32 calculation</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CRC32.GetCrc32AndCopy(System.IO.Stream,System.IO.Stream)">
            <summary>
            Returns the CRC32 for the specified stream, and writes the input into the output stream.
            </summary>
            <param name="input">The stream over which to calculate the CRC32</param>
            <param name="output">The stream into which to deflate the input</param>
            <returns>the CRC32 calculation</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CRC32.ComputeCrc32(System.Int32,System.Byte)">
            <summary>
            Get the CRC32 for the given (word,byte) combo. 
            This is a computation defined by PKzip.
            </summary>
            <param name="W">The word to start with.</param>
            <param name="B">The byte to combine it with.</param>
            <returns>The CRC-ized result.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CRC32.SlurpBlock(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Update the value for the running CRC32 using the given block of bytes.
            This is useful when using the CRC32() class in a Stream.
            </summary>
            <param name="block">block of bytes to slurp</param>
            <param name="offset">starting point in the block</param>
            <param name="count">how many bytes within the block to slurp</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CRC32.TotalBytesRead">
            <summary>
            indicates the total number of bytes read on the CRC stream.
            This is used when writing the ZipDirEntry when compressing files.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CRC32.Crc32Result">
            <summary>
            Indicates the current CRC for all blocks slurped in.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream">
             <summary>
             A Stream that calculates a CRC32 (a checksum) on all bytes read, 
             or on all bytes written.
             </summary>
            
             <remarks>
             <para>
             This class can be used to verify the CRC of a ZipEntry when reading from a stream, 
             or to calculate a CRC when writing to a stream.  The stream should be used to either 
             read, or write, but not both.  If you intermix reads and writes, the results are
             not defined. 
             </para>
             <para>This class is intended primarily for use internally by the DotNetZip library.</para>
             </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.#ctor(System.IO.Stream)">
            <summary>
            The constructor.
            </summary>
            <param name="stream">The underlying stream</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.#ctor(System.IO.Stream,System.Int64)">
            <summary>
            The constructor.
            </summary>
            <param name="stream">The underlying stream</param>
            <param name="length">The length of the stream to slurp</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Read from the stream
            </summary>
            <param name="buffer">the buffer to read</param>
            <param name="offset">the offset at which to start</param>
            <param name="count">the number of bytes to read</param>
            <returns>the number of bytes actually read</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.Write(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Write to the stream. 
            </summary>
            <param name="buffer">the buffer from which to write</param>
            <param name="offset">the offset at which to start writing</param>
            <param name="count">the number of bytes to write</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.Flush">
            <summary>
            Flush the stream.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.Seek(System.Int64,System.IO.SeekOrigin)">
            <summary>
            Not implemented.
            </summary>
            <param name="offset">N/A</param>
            <param name="origin">N/A</param>
            <returns>N/A</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.SetLength(System.Int64)">
            <summary>
            Not implemented.
            </summary>
            <param name="value">N/A</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.TotalBytesSlurped">
             <summary>
             Gets the total number of bytes run through the CRC32 calculator.
             </summary>
            
             <remarks>
             This is either the total number of bytes read, or the total number
             of bytes written, depending on the direction of this stream.
             </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.Crc32">
            <summary>
            Provides the current CRC for all blocks slurped in.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.CanRead">
            <summary>
            Indicates whether the stream supports reading. 
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.CanSeek">
            <summary>
            Indicates whether the stream supports seeking. 
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.CanWrite">
            <summary>
            Indicates whether the stream supports writing. 
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.Length">
            <summary>
            Not implemented.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CrcCalculatorStream.Position">
            <summary>
            Not implemented.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtilities">
            <summary>
            Collects general purpose utility methods.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtilities.#ctor">
            private null constructor
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtilities.RoundToEvenSecond(System.DateTime)">
             <summary>
             Round the given DateTime value to an even second value.  
             </summary>
            
             <remarks>
             <para>
             Round up in the case of an odd second value.  The rounding does not consider fractional seconds.
             </para>
             <para>
             This is useful because the Zip spec allows storage of time only to the nearest even second.
             So if you want to compare the time of an entry in the archive with it's actual time in the filesystem, you 
             need to round the actual filesystem time, or use a 2-second threshold for the  comparison. 
             </para>
             <para>
             This is most nautrally an extension method for the DateTime class but this library is 
             built for .NET 2.0, not for .NET 3.5;  This means extension methods are a no-no.  
             </para>
             </remarks>
             <param name="source">The DateTime value to round</param>
             <returns>The ruonded DateTime value</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtilities.TrimVolumeAndSwapSlashes(System.String)">
            <summary>
            Utility routine for transforming path names. 
            </summary>
            <param name="pathName">source path.</param>
            <returns>transformed path</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtilities.FindSignature(System.IO.Stream,System.Int32)">
            <summary>
            Finds a signature in the zip stream. This is useful for finding 
            the end of a zip entry, for example. 
            </summary>
            <param name="stream"></param>
            <param name="SignatureToFind"></param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtilities.StringToMemoryStream(System.String)">
            <summary>
            Creates a <c>MemoryStream</c> for the given string. This is used internally by Library, specifically by 
            the ZipFile.AddStringAsFile() method.   But it may be useful in other scenarios. 
            </summary>
            <param name="s">The string to use as input for the MemoryStream</param>
            <returns>the MemoryStream. Reading the stream will give you the content of the String.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtilities.GetTempFilename">
            <summary>
            Return a random filename, suitable for use as a temporary file.
            </summary>
            <remarks>
            The System.IO.Path.GetRandomFileName() method is not available on the Compact
            Framework, so this library provides its own substitute. 
            </remarks>
            <returns>a filename of the form DotNetZip-xxxxxxxx.tmp, where xxxxxxxx is replaced 
            by randomly chosen characters.</returns>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CountingStream">
            <summary> 
            A Stream wrapper, used for bookkeeping on input or output
            streams.  In some cases, it is not possible to get the Position
            of a stream, let's say, on a write-only output stream like
            ASP.NET's Response.Output, or on a different write-only stream
            provided as the destination for the zip by the application.
            In this case, we can use this counting stream to count the bytes
            read or written.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CountingStream.#ctor(System.IO.Stream)">
            <summary>
            The  constructor.
            </summary>
            <param name="s">The underlying stream</param>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Properties.Resources">
            <summary>
              A strongly-typed resource class, for looking up localized strings, etc.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Properties.Resources.ResourceManager">
            <summary>
              Returns the cached ResourceManager instance used by this class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Properties.Resources.Culture">
            <summary>
              Overrides the current thread's CurrentUICulture property for all
              resource lookups using this strongly typed resource class.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream">
            <summary>
            A class for compressing and decompressing streams using the Deflate algorithm.
            </summary>
            <remarks>
            <para>
            Data can be compressed or decompressed, and either of those can be through reading or writing. 
            For more information on the Deflate algorithm, see IETF RFC 1951, "DEFLATE Compressed Data 
            Format Specification version 1.3." 
            </para>
            <para>
            This class is similar to ZlibStream, except that <c>ZlibStream</c> adds the RFC1950 
            header bytes to a compressed stream when compressing, or expects the RFC1950 header bytes when 
            decompressing. The <c>DeflateStream</c> does not.
            </para>
            </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.#ctor(System.IO.Stream,ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionMode,System.Boolean)">
            <summary>
            Create a DeflateStream using the specified CompressionMode, and explicitly specify whether
            the stream should be left open after Deflation or Inflation.
            </summary>
            <remarks>
            <para>
            This constructor allows the application to request that the captive stream remain open after
            the deflation or inflation occurs.  By default, after Close() is called on the stream, the 
            captive stream is also closed. In some cases this is not desired, for example if the stream 
            is a memory stream that will be re-read after compression.  Specify true for the 
            leaveOpen parameter to leave the stream open. 
            </para>
            <para>
            The DeflateStream will use the default compression level.
            </para>
            <para>
            See the other overloads of this constructor for example code.
            </para>
            </remarks>
            <param name="stream">The stream which will be read or written. This is called the 
            "captive" stream in other places in this documentation.</param>
            <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
            <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.#ctor(System.IO.Stream,ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionMode,ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel,System.Boolean)">
            <summary>
            Create a DeflateStream using the specified CompressionMode and the specified CompressionLevel, 
            and explicitly specify whether
            the stream should be left open after Deflation or Inflation.
            </summary>
            <remarks>
            <para>
            This constructor allows the application to request that the captive stream remain open after
            the deflation or inflation occurs.  By default, after Close() is called on the stream, the 
            captive stream is also closed. In some cases this is not desired, for example if the stream 
            is a memory stream that will be re-read after compression.  Specify true for the 
            leaveOpen parameter to leave the stream open. 
            </para>
            </remarks>
            <example>
            This example shows how to use a DeflateStream to compress data.
            <code>
            using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
            {
                using (var raw = System.IO.File.Create(outputFile))
                {
                    using (Stream compressor = new DeflateStream(raw, CompressionMode.Compress, true))
                    {
                        byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                        int n= -1;
                        while (n != 0)
                        {
                            if (n &gt; 0) 
                                compressor.Write(buffer, 0, n);
                            n= input.Read(buffer, 0, buffer.Length);
                        }
                    }
                }
            }
            </code>
            <code lang="VB">
            Dim outputFile As String = (fileToCompress &amp; ".compressed")
            Using input As Stream = File.OpenRead(fileToCompress)
                Using raw As FileStream = File.Create(outputFile)
            	Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress, True)
            	    Dim buffer As Byte() = New Byte(4096) {}
            	    Dim n As Integer = -1
            	    Do While (n &lt;&gt; 0)
            		If (n &gt; 0) Then
            		    compressor.Write(buffer, 0, n)
            		End If
            		n = input.Read(buffer, 0, buffer.Length)
            	    Loop
            	End Using
                End Using
            End Using
            </code>
            </example>
            <param name="stream">The stream which will be read or written.</param>
            <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
            <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
            <param name="level">A tuning knob to trade speed for effectiveness.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.Close">
            <summary>
            Close the stream.  
            </summary>
            <remarks>
            This may or may not close the captive stream. 
            See the ctor's with leaveOpen parameters for more information.
            </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.Flush">
            <summary>
            Flush the stream.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Read data from the stream. 
            </summary>
            <remarks>
            <para>
            If you wish to use the DeflateStream to compress data while reading, you can create a DeflateStream with 
            CompressionMode.Compress, providing an uncompressed data stream.  Then call Read() on that DeflateStream, 
            and the data read will be compressed. 
            If you wish to use the DeflateStream to decompress data while reading, you can create a DeflateStream with 
            CompressionMode.Decompress, providing a readable compressed data stream.  Then call Read() on that DeflateStream, 
            and the data read will be decompressed. 
            </para>
            <para>
            A DeflateStream can be used for Read() or Write(), but not both. 
            </para>
            </remarks>
            <param name="buffer">The buffer into which the read data should be placed.</param>
            <param name="offset">the offset within that data array to put the first byte read.</param>
            <param name="count">the number of bytes to read.</param>
            <returns>the number of bytes actually read</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.Seek(System.Int64,System.IO.SeekOrigin)">
            <summary>
            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.
            </summary>
            <param name="offset">this is irrelevant, since it will always throw!</param>
            <param name="origin">this is irrelevant, since it will always throw!</param>
            <returns>irrelevant!</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.SetLength(System.Int64)">
            <summary>
            Calling this method always throws a NotImplementedException.
            </summary>
            <param name="value">this is irrelevant, since it will always throw!</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.Write(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Write data to the stream. 
            </summary>
            <remarks>
            <para>
            If you wish to use the DeflateStream to compress data while writing, you can create a DeflateStream with 
            CompressionMode.Compress, and a writable output stream.  Then call Write() on that DeflateStream, 
            providing uncompressed data as input.  The data sent to the output stream will be the compressed form of the data written.
            If you wish to use the DeflateStream to decompress data while writing, you can create a DeflateStream with 
            CompressionMode.Decompress, and a writable output stream.  Then call Write() on that stream, providing previously 
            compressed data. The data sent to the output stream will be the decompressed form of the data written.   
            </para>
            <para>
            A DeflateStream can be used for Read() or Write(), but not both. 
            </para>
            </remarks>
            <param name="buffer">The buffer holding data to write to the stream.</param>
            <param name="offset">the offset within that data array to find the first byte to write.</param>
            <param name="count">the number of bytes to write.</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.FlushMode">
            <summary>
            This property sets the flush behavior on the stream.  
            Sorry, though, not sure exactly how to describe all the various settings.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.BufferSize">
            <summary>
            Callers can set the buffer size of the working buffer with this property.  
            </summary>
            <remarks>
            The working buffer is used for all stream operations.
            The default size is 1024 bytes.  The minimum size is 128 bytes. You may get better 
            performance with a larger buffer.  Then again, you might not.  I don't know, I haven't tested it.  
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.TotalIn">
            <summary> Returns the total number of bytes input so far.</summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.TotalOut">
            <summary> Returns the total number of bytes output so far.</summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.CanRead">
            <summary>
            Indicates whether the stream can be read.
            </summary>
            <remarks>
            The return value depends on whether the captive stream supports reading.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.CanSeek">
            <summary>
            Indicates whether the stream supports Seek operations.
            </summary>
            <remarks>
            Always returns false.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.CanWrite">
            <summary>
            Indicates whether the stream can be written.
            </summary>
            <remarks>
            The return value depends on whether the captive stream supports writing.
            </remarks>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.Length">
            <summary>
            Reading this property always throws a NotImplementedException.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.DeflateStream.Position">
            <summary>
            Reading or Writing this property always throws a NotImplementedException.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle">
            <summary>
            Internal representation of a KML style element.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.CopyFrom(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle)">
            <summary>
            Copies a KML style object contents to another KML object.
            </summary>
            <param name="from">The source of the copy (contents copied to instance invoking this method).</param>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.StyleId">
            <summary>
            The unique id of the style. This is either the "id" of the Style node, the filename of an image if taken
            from a KMZ file generated by ArcGIS REST, or a unique GUID for styles that are encountered "in-line" for
            a point feature in order to link the feature to the style/icon for later processing.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.IconHref">
            <summary>
            The href to the icon image used for a point feature.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.IconOffsetX">
            <summary>
            The number of horizontal pixels offset from the upper left origin used to draw a point symbol.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.IconOffsetY">
            <summary>
            The number of vertical pixels offset from the upper left origin used to draw a point symbol.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.IconHeading">
            <summary>
            The angle of rotation for the point image between 0 and 360.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.IconScale">
            <summary>
            The scale of the point image.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.IconImage">
            <summary>
            The bitmap image used to draw the point symbol.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.LineWidth">
            <summary>
            The width in pixels used to draw the line segment.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.LineColor">
            <summary>
            The color used to draw the line segment.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.PolyFill">
            <summary>
            If true the polygon will be filled with a color, if false it will not be filled.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.PolyOutline">
            <summary>
            If true the polygon outline will be drawn independently of the inside, if false it will not
            be drawn.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle.PolyFillColor">
            <summary>
            The color used to fill the polygon.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.SymbolDescriptor">
            <summary>
            Abstract base class used for each type of symbol descriptor.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.SymbolDescriptor.CreateSymbol">
            <summary>
            Method to create proper symbology for each feature type.
            </summary>
            <returns>A symbol defined by internal properties of the class.</returns>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.PointSymbolDescriptor">
            <summary>
            Concrete class for point geometry symbols.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.PointSymbolDescriptor.CreateSymbol">
            <summary>
            Method to create proper symbology for each feature type.
            </summary>
            <returns>A symbol defined by internal properties of the class.</returns>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.LineSymbolDescriptor">
            <summary>
            Concrete class for line geometry symbols.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.LineSymbolDescriptor.CreateSymbol">
            <summary>
            Method to create proper symbology for each feature type.
            </summary>
            <returns>A symbol defined by internal properties of the class.</returns>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.PolygonSymbolDescriptor">
            <summary>
            Concrete class for polygon geometry symbols.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.PolygonSymbolDescriptor.CreateSymbol">
            <summary>
            Method to create proper symbology for each feature type.
            </summary>
            <returns>A symbol defined by internal properties of the class.</returns>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDescriptor">
            <summary>
            Metadata storage for each feature, assigned by KML engine.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDescriptor.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDescriptor"/> class.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDescriptor.Geometry">
            <summary>
            Information that defines the feature geometry and its location.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDescriptor.Symbol">
            <summary>
            Information that defines the symbology of the feature.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDescriptor.Attributes">
            <summary>
            Attributes associated with the feature.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition">
            <summary>
            Metadata storage for all elements in a KML file.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition"/> class.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.Clear">
            <summary>
            Clear all features. This is invoked by the KML engine so that it can cleanly process multiple
            KML files with each as a separate graphics layer.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.AddFeature(ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDescriptor)">
            <summary>
            Adds a feature descriptor to the list.
            </summary>
            <param name="fd">Feature description.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.AddStyle(System.String,ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KMLStyle)">
            <summary>
            Adds a KML style to the list.
            </summary>
            <param name="key">Unique key associated with the style, typically an id, filename or GUID.</param>
            <param name="style">Style description.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.AddImage(System.String,System.Windows.Media.ImageBrush)">
            <summary>
            Adds an image to the list.
            </summary>
            <param name="key">Unique key associated with the image, typically a filename or an HREF.</param>
            <param name="image">Bitmap image.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.AddNetworkLink(System.String)">
            <summary>
            Adds a network link HREF to the list.
            </summary>
            <param name="href">HREF to a KML/KMZ file.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.GetIconImage(System.String)">
            <summary>
            Returns the bitmap image brush associated with the icon href for the point feature.
            </summary>
            <param name="IconHref">Value used to obtain image from remote server via HTTP or key for image dictionary.</param>
            <returns>A bitmap image brush or null if not found.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.FeatureDefinition.CreateGraphics(ESRI.ArcGIS.Client.Toolkit.DataSources.KmlLayer)">
            <summary>
            Creates graphic elements and adds them to the graphics layer.
            </summary>
            <param name="layer">Graphics layer that will have features added to it.</param>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec">
            <summary>
            Encoder and Decoder for ZLIB (IETF RFC1950 and RFC1951).
            </summary>
            <remarks>
            This class compresses and decompresses data according to the Deflate algorithm documented in RFC1950 and RFC1951. 
            </remarks>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.InputBuffer">
            <summary>
            The buffer from which data is taken.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.NextIn">
            <summary>
            An index into the InputBuffer array, indicating where to start reading. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.AvailableBytesIn">
            <summary>
            The number of bytes available in the InputBuffer, starting at NextIn. 
            </summary>
            <remarks>
            Generally you should set this to InputBuffer.Length before the first Inflate() or Deflate() call. 
            The class will update this number as calls to Inflate/Deflate are made.
            </remarks>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.TotalBytesIn">
            <summary>
            Total number of bytes read so far, through all calls to Inflate()/Deflate().
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.OutputBuffer">
            <summary>
            Buffer to store output data.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.NextOut">
            <summary>
            An index into the OutputBuffer array, indicating where to start writing. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.AvailableBytesOut">
            <summary>
            The number of bytes available in the OutputBuffer, starting at NextOut. 
            </summary>
            <remarks>
            Generally you should set this to OutputBuffer.Length before the first Inflate() or Deflate() call. 
            The class will update this number as calls to Inflate/Deflate are made.
            </remarks>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.TotalBytesOut">
            <summary>
            Total number of bytes written to the output so far, through all calls to Inflate()/Deflate().
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.Message">
            <summary>
            used for diagnostics, when something goes wrong!
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.#ctor">
            <summary>
            Create a ZlibCodec.
            </summary>
            <remarks>
            If you use this default constructor, you will later have to explicitly call 
            InitializeInflate() or InitializeDeflate() before using the ZlibCodec to compress 
            or decompress. 
            </remarks>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.InitializeInflate">
            <summary>
            Initialize the inflation state. 
            </summary>
            <remarks>
            It is not necessary to call this before using the ZlibCodec to inflate data; 
            It is implicitly called when you call the constructor.
            </remarks>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.InitializeInflate(System.Boolean)">
            <summary>
            Initialize the inflation state with an explicit flag to govern the handling of RFC1950 header bytes. 
            </summary>
            <remarks>
            By default, the RFC1950 header is expected.  If you want to read a zlib stream 
            you should specify true for expectRfc1950Header.  If you have a deflate stream, you will
            want to specify false. It is only necessary to invoke this initializer explicitly if you want 
            to specify false.
            </remarks>
            <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading the stream of data to be inflated.</param>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.InitializeInflate(System.Int32)">
            <summary>
            Initialize the ZlibCodec for inflation, with the specified number of window bits. 
            </summary>
            <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
            then you shouldn't be calling this initializer.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.InitializeInflate(System.Int32,System.Boolean)">
            <summary>
            Initialize the inflation state with an explicit flag to govern the handling of RFC1950 header bytes. 
            </summary>
            <remarks>
            If you want to read a zlib stream 
            you should specify true for expectRfc1950Header.  If you have a deflate stream, you will
            want to specify false. 
            </remarks>
            <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading 
            the stream of data to be inflated.</param>
            <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
            then you shouldn't be calling this initializer.</param>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.Inflate(System.Int32)">
             <summary>
             Inflate the data in the InputBuffer, placing the result in the OutputBuffer.
             </summary>
             <remarks>
             You must have set InputBuffer and OutputBuffer, NextIn and NextOut, and AvailableBytesIn and 
             AvailableBytesOut  before calling this method.
             </remarks>
             <example>
             <code>
             private void InflateBuffer()
             {
                 int bufferSize = 1024;
                 byte[] buffer = new byte[bufferSize];
                 ZlibCodec decompressor = new ZlibCodec();
             
                 Console.WriteLine("\n============================================");
                 Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);
                 MemoryStream ms = new MemoryStream(DecompressedBytes);
             
                 int rc = decompressor.InitializeInflate();
             
                 decompressor.InputBuffer = CompressedBytes;
                 decompressor.NextIn = 0;
                 decompressor.AvailableBytesIn = CompressedBytes.Length;
             
                 decompressor.OutputBuffer = buffer;
             
                 // pass 1: inflate 
                 do
                 {
                     decompressor.NextOut = 0;
                     decompressor.AvailableBytesOut = buffer.Length;
                     rc = decompressor.Inflate(ZlibConstants.Z_NO_FLUSH);
             
                     if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
                         throw new Exception("inflating: " + decompressor.Message);
             
                     ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
                 }
                 while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
             
                 // pass 2: finish and flush
                 do
                 {
                     decompressor.NextOut = 0;
                     decompressor.AvailableBytesOut = buffer.Length;
                     rc = decompressor.Inflate(ZlibConstants.Z_FINISH);
             
                     if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
                         throw new Exception("inflating: " + decompressor.Message);
             
                     if (buffer.Length - decompressor.AvailableBytesOut &gt; 0)
                         ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);
                 }
                 while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
             
                 decompressor.EndInflate();
             }
            
             </code>
             </example>
             <param name="f">I think you want to set this to Z_NO_FLUSH.</param>
             <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.EndInflate">
            <summary>
            Ends an inflation session. 
            </summary>
            <remarks>
            Call this after successively calling Inflate().  This will cause all buffers to be flushed. 
            After calling this you cannot call Inflate() without a intervening call to one of the
            InitializeInflate() overloads.
            </remarks>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.SyncInflate">
            <summary>
            I don't know what this does!
            </summary>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.SetDictionary(System.Byte[])">
            <summary>
            Set the dictionary to be used for either Inflation or Deflation.
            </summary>
            <param name="dictionary">The dictionary bytes to use.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibCodec.Adler32">
            <summary>
            The Adler32 checksum on the data transferred through the codec so far. You probably don't need to look at this.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel">
            <summary>
            The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.NONE">
            <summary>
            NONE means that the data will be simply stored, with no change at all.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL0_NONE">
            <summary>
            Same as NONE.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.BEST_SPEED">
            <summary>
            The fastest but least effective compression.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL1_BEST_SPEED">
            <summary>
            A synonym for BEST_SPEED.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL2">
            <summary>
            A little slower, but better, than level 1.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL3">
            <summary>
            A little slower, but better, than level 2.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL4">
            <summary>
            A little slower, but better, than level 3.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL5">
            <summary>
            A little slower, but better, than level 4.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.DEFAULT">
            <summary>
            The default compression level.  Do these levels even matter?  Do people even care?  
            I have never measured the speed difference.  
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL6_DEFAULT">
            <summary>
            A synonym for DEFAULT.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL7">
            <summary>
            Pretty good compression!
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL8">
            <summary>
             Still better compression!
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.BEST_COMPRESSION">
            <summary>
            The "best" compression, where best means greatest reduction in size of the input data stream. 
            This is also the slowest compression.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionLevel.LEVEL9_BEST_COMPRESSION">
            <summary>
            A synonym for BEST_COMPRESSION.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionStrategy">
            <summary>
            I honestly don't know what this means, but it is possible to set it in the SetDeflateParameters() call.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionStrategy.DEFAULT">
            <summary>
            It's probably safest to just leave this alone, or select the default. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionStrategy.FILTERED">
            <summary>
            I don't know what this does. 
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionStrategy.HUFFMAN_ONLY">
            <summary>
            I don't know what this setting does either.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionMode">
            <summary>
            An enum to specify the direction of transcoding - whether to compress or decompress.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.CompressionMode.Decompress">
            <summary>
            Used to specify that the stream should decompress the data.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibException">
            <summary>
            A general purpose exception class for exceptions in the Zlib library.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibException.#ctor">
            <summary>
            The ZlibException class captures exception information generated
            by the Zlib library. 
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZlibException.#ctor(System.String)">
            <summary>
            This ctor collects a message attached to the exception.
            </summary>
            <param name="s"></param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtils.URShift(System.Int32,System.Int32)">
            <summary>
            Performs an unsigned bitwise right shift with the specified number
            </summary>
            <param name="number">Number to operate on</param>
            <param name="bits">Ammount of bits to shift</param>
            <returns>The resulting number from the shift operation</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtils.URShift(System.Int32,System.Int64)">
            <summary>
            Performs an unsigned bitwise right shift with the specified number
            </summary>
            <param name="number">Number to operate on</param>
            <param name="bits">Ammount of bits to shift</param>
            <returns>The resulting number from the shift operation</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtils.URShift(System.Int64,System.Int32)">
            <summary>
            Performs an unsigned bitwise right shift with the specified number
            </summary>
            <param name="number">Number to operate on</param>
            <param name="bits">Ammount of bits to shift</param>
            <returns>The resulting number from the shift operation</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtils.URShift(System.Int64,System.Int64)">
            <summary>
            Performs an unsigned bitwise right shift with the specified number
            </summary>
            <param name="number">Number to operate on</param>
            <param name="bits">Ammount of bits to shift</param>
            <returns>The resulting number from the shift operation</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtils.ReadInput(System.IO.Stream,System.Byte[],System.Int32,System.Int32)">
            <summary>Reads a number of characters from the current source Stream and writes the data to the target array at the specified index.</summary>
            <param name="sourceStream">The source Stream to read from.</param>
            <param name="target">Contains the array of characteres read from the source Stream.</param>
            <param name="start">The starting index of the target array.</param>
            <param name="count">The maximum number of characters to read from the source Stream.</param>
            <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source Stream. Returns -1 if the end of the stream is reached.</returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.SharedUtils.ReadInput(System.IO.TextReader,System.Byte[],System.Int32,System.Int32)">
            <summary>Reads a number of characters from the current source TextReader and writes the data to the target array at the specified index.</summary>
            <param name="sourceTextReader">The source TextReader to read from</param>
            <param name="target">Contains the array of characteres read from the source TextReader.</param>
            <param name="start">The starting index of the target array.</param>
            <param name="count">The maximum number of characters to read from the source TextReader.</param>
            <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source TextReader. Returns -1 if the end of the stream is reached.</returns>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.Adler">
            <summary>
            Computes an Adler-32 checksum. 
            </summary>
            <remarks>
            The Adler checksum is similar to a CRC checksum, but faster to compute, though less reliable.  
            It is used in producing RFC1950 compressed streams.  The Adler checksum is a required part of the "ZLIB" standard.
            Applications will almost never need to use this class directly. 
            </remarks>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadReadException">
            <summary>
            Indicates that a read was attempted on a stream, and bad or incomplete data was
            received.  
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipException">
            <summary>
            Base class for all exceptions defined by and throw by the Zip library.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.ZipException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadReadException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadReadException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadReadException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadReadException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadCrcException">
            <summary>
            Issued when an CRC check fails upon extracting an entry from a zip archive.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadCrcException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadCrcException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadCrcException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.Zip.BadCrcException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer">
            <summary>
            Heat Map layer
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer"/> class.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.IntensityProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.Intensity"/> dependency property.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.OnIntensityPropertyChanged(System.Windows.DependencyObject,System.Windows.DependencyPropertyChangedEventArgs)">
            <summary>
            IntervalProperty property changed handler. 
            </summary>
            <param name="d">HeatMapLayer that changed its Interval.</param>
            <param name="e">DependencyPropertyChangedEventArgs.</param> 
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.heatMapPoints_CollectionChanged(System.Object,System.Collections.Specialized.NotifyCollectionChangedEventArgs)">
            <summary>
            Handles the CollectionChanged event of the heatMapPoints control.
            </summary>
            <param name="sender">The source of the event.</param>
            <param name="e">The <see cref="T:System.Collections.Specialized.NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.GradientProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.Gradient"/> dependency property.
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.OnGradientPropertyChanged(System.Windows.DependencyObject,System.Windows.DependencyPropertyChangedEventArgs)">
            <summary>
            GradientProperty property changed handler. 
            </summary>
            <param name="d">HeatMapLayer that changed its Gradient.</param>
            <param name="e">DependencyPropertyChangedEventArgs.</param> 
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.GetSource(ESRI.ArcGIS.Client.Geometry.Envelope,System.Int32,System.Int32,ESRI.ArcGIS.Client.DynamicLayer.OnImageComplete)">
            <summary>
            Gets the source image to display in the dynamic layer. Override this to generate
            or modify images.
            </summary>
            <param name="extent">The extent of the image being requested.</param>
            <param name="width">The width of the image being requested.</param>
            <param name="height">The height of the image being requested.</param>
            <param name="onComplete">The method to call when the image is ready.</param>
            <seealso cref="M:ESRI.ArcGIS.Client.DynamicLayer.OnProgress(System.Int32)"/>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.Cancel">
            <summary>
            Stops loading of any pending images
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.renderThread_DoWork(System.Object,System.ComponentModel.DoWorkEventArgs)">
            <summary>
            Handles the DoWork event of the renderThread control. This is where we
            render the heatmap outside the UI thread.
            </summary>
            <param name="sender">The source of the event.</param>
            <param name="e">The <see cref="T:System.ComponentModel.DoWorkEventArgs"/> instance 
            containing the event data.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.renderThread_RunWorkerCompleted(System.Object,System.ComponentModel.RunWorkerCompletedEventArgs)">
            <summary>
            Handles the RunWorkerCompleted event of the renderThread control.
            </summary>
            <param name="sender">The source of the event.</param>
            <param name="e">The <see cref="T:System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.renderThread_ProgressChanged(System.Object,System.ComponentModel.ProgressChangedEventArgs)">
            <summary>
            Handles the ProgressChanged event of the renderThread control and fires the layer progress event.
            </summary>
            <param name="sender">The source of the event.</param>
            <param name="e">The <see cref="T:System.ComponentModel.ProgressChangedEventArgs"/> instance containing the event data.</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.InterpolateColor(System.Single,System.Collections.Generic.List{ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.ThreadSafeGradientStop})">
            <summary>
            Lienarly interpolates a color from a list of colors.
            </summary>
            <param name="value">The value relative to the gradient stop offsets.</param>
            <param name="stops">The color stops sorted by the offset.</param>
            <returns></returns>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.AddPoint(System.UInt16[],System.Int32,System.Int32,System.Int32,System.Int32[],System.Int32)">
            <summary>
            Adds a heat map point to the intensity matrix.
            </summary>
            <param name="distanceMatrix">The distance matrix.</param>
            <param name="size">The size of the distance matrix.</param>
            <param name="x">x.</param>
            <param name="y">y</param>
            <param name="intensityMap">The intensity map.</param>
            <param name="width">The width of the intensity map..</param>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.CreateDistanceMatrix(System.Int32)">
            <summary>
            Creates the distance matrix.
            </summary>
            <param name="size">The size of the matrix (must be and odd number).</param>
            <returns></returns>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.FullExtent">
            <summary>
            The full extent of the layer.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.Intensity">
            <summary>
            Gets or sets the interval.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.HeatMapPoints">
            <summary>
            Gets or sets the heat map points.
            </summary>
            <value>The heat map points.</value>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.HeatMapLayer.Gradient">
            <summary>
            Gets or sets the heat map gradient.
            </summary>
        </member>
        <member name="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol">
            <summary>
            Point symbol using a bitmap image for symbol
            </summary>
        </member>
        <member name="M:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol"/> class.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.FillProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Fill"/> dependency property.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.WidthProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Width"/> dependency property.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.HeightProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Height"/> dependency property.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.OpacityProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Opacity"/> dependency property.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.HeadingProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Heading"/> dependency property.
            </summary>
        </member>
        <member name="F:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.ScaleProperty">
            <summary>
            Identifies the <see cref="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Scale"/> dependency property.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Fill">
            <summary>
            Gets or sets Fill.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Width">
            <summary>
            Gets or sets the width of the image.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Height">
            <summary>
            Gets or sets the height of the image.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Opacity">
            <summary>
            Gets or sets the opacity of the image.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Heading">
            <summary>
            Gets or sets the heading of the image.
            </summary>
        </member>
        <member name="P:ESRI.ArcGIS.Client.Toolkit.DataSources.Kml.KmlPlaceMarkerSymbol.Scale">
            <summary>
            Gets or sets the scale of the image.
            </summary>
        </member>
    </members>
</doc>
